import 'dart:developer' as developer;
import 'dart:io';
import 'dart:typed_data'; // 🔥 导入Int64List支持
import 'package:flutter/material.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:get/get.dart';
import 'package:permission_handler/permission_handler.dart';
// import '../routers/names.dart'; // 🔥 导入路由名称 - 已禁用跳转功能，暂时不需要
// 🔥 导入极光推送插件（已添加依赖）
import 'package:jpush_flutter/jpush_flutter.dart';
import 'package:jpush_flutter/jpush_interface.dart';

// 🔥 启用标志 - 极光推送已准备就绪
const bool ENABLE_JPUSH_CODE = true; // 🔥 已添加jpush_flutter依赖，启用代码

/// 本地通知服务 - 参考MyApplication2的通知实现，现在集成极光推送
class NotificationService extends GetxService {
  static NotificationService get to => Get.find();

  final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin =
      FlutterLocalNotificationsPlugin();

  // 🔥 极光推送相关配置
  JPushFlutterInterface? _jPush; // 极光推送实例
  String? _jPushRegistrationId; // 极光推送注册ID
  bool _jPushInitialized = false; // 极光推送是否已初始化
  Map<String, dynamic> _jPushConfig = {}; // 极光推送配置信息
  
  // 🔥 极光推送配置参数（玩真的应用配置）
  static const String JPUSH_APP_KEY = "09a7d1e089ee25fde90cde49"; // 🔥 玩真的极光App Key
  static const String JPUSH_MASTER_SECRET = "8b4dca53d46f3ca858594586"; // 🔥 Master Secret（服务端使用）
  static const String JPUSH_PACKAGE_NAME = "com.playtruly.wanzhende2025"; // 🔥 应用包名
  static const String JPUSH_CHANNEL = "developer-default"; // 🔥 渠道名称
  static const bool JPUSH_DEBUG_MODE = true; // 🔥 调试模式开关（生产环境请改为false）

  @override
  Future<void> onInit() async {
    super.onInit();
    await _initializeNotifications();
    // 🔥 初始化极光推送
    await _initializeJPush();
  }

  /// 🔥 初始化极光推送服务
  Future<void> _initializeJPush() async {
    try {
      developer.log('🚀 =============== 开始初始化极光推送服务 ===============');
      
      // 🔥 打印极光推送初始化配置
      _printJPushInitConfig();
      
      // 🔥 检查是否启用极光推送代码
      if (ENABLE_JPUSH_CODE) {
        developer.log('✅ 极光推送代码已启用，开始真实初始化...');
        
        // 🔥 真实的极光推送初始化代码（3.3.6版本API）
        _jPush = JPush.newJPush();
        
        // 🔥 初始化极光推送（使用新版本API）
        _jPush!.setup(
          appKey: JPUSH_APP_KEY,
          channel: JPUSH_CHANNEL,
          production: false, // 设置为开发环境，生产环境请改为true
          debug: JPUSH_DEBUG_MODE,
        );
        developer.log('✅ 极光推送真实初始化完成');
        developer.log('🔧 极光推送调试模式设置: $JPUSH_DEBUG_MODE');
        
        // 🔥 获取Registration ID（新版本API）
        _jPush!.getRegistrationID().then((rid) {
          _jPushRegistrationId = rid;
          developer.log('📱 极光推送Registration ID: $rid');
        });
        
        // 🔥 设置消息接收监听器（新版本API）
        _jPush!.addEventHandler(
          onReceiveNotification: (Map<String, dynamic> message) async {
            developer.log('📥 收到极光推送通知: $message');
            await _handleJPushNotification(message);
          },
          onOpenNotification: (Map<String, dynamic> message) async {
            developer.log('👆 用户点击了极光推送通知: $message');
            await _handleJPushNotificationClick(message);
          },
          onReceiveMessage: (Map<String, dynamic> message) async {
            developer.log('📨 收到极光推送自定义消息: $message');
            await _handleJPushCustomMessage(message);
          },
        );
        
        _jPushInitialized = true;
        developer.log('🎉 极光推送真实初始化成功完成');
        
      } else {
        developer.log('⚠️ 极光推送代码未启用 (ENABLE_JPUSH_CODE = false)');
        developer.log('📝 启用步骤:');
        developer.log('   1. 在pubspec.yaml中添加: jpush_flutter: ^2.3.9');
        developer.log('   2. 取消注释: import \'package:jpush_flutter/jpush_flutter.dart\';');
        developer.log('   3. 设置: const bool ENABLE_JPUSH_CODE = true;');
        developer.log('   4. 取消注释上面的真实初始化代码');
        _jPushInitialized = false;
      }
      
      // 🔥 打印极光推送完整配置信息
      await _printJPushCompleteConfig();
      
      developer.log('🎯 =============== 极光推送服务初始化完成 ===============');
      
    } catch (e) {
      developer.log('💥 极光推送初始化异常: $e');
      _jPushInitialized = false;
    }
  }

  /// 初始化本地通知（参考MyApplication2的Android通知配置）
  Future<void> _initializeNotifications() async {
    try {
      developer.log('🔔 初始化本地通知服务...');

      // Android初始化设置
      const AndroidInitializationSettings initializationSettingsAndroid =
          AndroidInitializationSettings('@mipmap/launcher_icon');

      // iOS初始化设置
      const DarwinInitializationSettings initializationSettingsDarwin =
          DarwinInitializationSettings(
        requestSoundPermission: true,
        requestBadgePermission: true,
        requestAlertPermission: true,
        onDidReceiveLocalNotification: null,
      );

      // 综合初始化设置
      const InitializationSettings initializationSettings = InitializationSettings(
        android: initializationSettingsAndroid,
        iOS: initializationSettingsDarwin,
        macOS: initializationSettingsDarwin,
      );

      // 初始化插件
      await _flutterLocalNotificationsPlugin.initialize(
        initializationSettings,
        onDidReceiveNotificationResponse: _onDidReceiveNotificationResponse,
        onDidReceiveBackgroundNotificationResponse: _onDidReceiveNotificationResponse,
      );

      // 创建Android通知渠道（参考MyApplication2）
      await _createNotificationChannel();

      // 请求权限
      await _requestPermissions();

      developer.log('✅ 本地通知服务初始化成功');
    } catch (e) {
      developer.log('💥 本地通知初始化异常: $e');
    }
  }

  /// 创建Android通知渠道（增强版，支持HEAD_UP显示）
  Future<void> _createNotificationChannel() async {
    try {
      if (Platform.isAndroid) {
        // 🔥 创建支持HEAD_UP的高优先级通知渠道
        const AndroidNotificationChannel channel = AndroidNotificationChannel(
          'default_channel',
          '新消息',
          description: '您有一条新消息',
          importance: Importance.max, // 🔥 最高重要性，确保HEAD_UP显示
          enableVibration: true,
          showBadge: true,
          playSound: true,
          enableLights: true, // 🔥 启用LED指示灯
          ledColor: Color(0xFFD94841), // 🔥 使用app主题色
        );

        final AndroidFlutterLocalNotificationsPlugin? androidPlugin =
            _flutterLocalNotificationsPlugin.resolvePlatformSpecificImplementation<
                AndroidFlutterLocalNotificationsPlugin>();

        if (androidPlugin != null) {
          await androidPlugin.createNotificationChannel(channel);
          developer.log('✅ Android增强通知渠道创建成功（支持HEAD_UP）');
        }
      }
    } catch (e) {
      developer.log('💥 创建通知渠道异常: $e');
    }
  }

  /// 请求通知权限（Android 13+需要）
  Future<void> _requestPermissions() async {
    try {
      if (Platform.isAndroid) {
        developer.log('🔍 开始检查Android通知权限...');
        
        // Android 13+ 需要通知权限
        final status = await Permission.notification.status;
        developer.log('📱 当前通知权限状态: $status');
        
        if (status.isDenied || status.isPermanentlyDenied) {
          developer.log('⚠️ 通知权限被拒绝，尝试请求权限');
          final result = await Permission.notification.request();
          developer.log('📱 通知权限请求结果: $result');
          
          if (result.isPermanentlyDenied) {
            developer.log('❌ 通知权限被永久拒绝，需要用户手动开启');
            // 可以引导用户去设置页面开启权限
            // openAppSettings();
          }
        }

        // 🔥 新增：检查通知渠道是否启用
        await _checkNotificationChannelStatus();
        
        // 检查是否支持精确闹钟权限
        final alarmStatus = await Permission.scheduleExactAlarm.status;
        developer.log('⏰ 精确闹钟权限状态: $alarmStatus');
        if (alarmStatus.isDenied) {
          final alarmResult = await Permission.scheduleExactAlarm.request();
          developer.log('⏰ 精确闹钟权限请求结果: $alarmResult');
        }

        // 🔥 检查系统级弹出窗口权限（用于HEAD_UP通知）
        final systemAlertStatus = await Permission.systemAlertWindow.status;
        developer.log('📱 系统弹出窗口权限状态: $systemAlertStatus');
        if (systemAlertStatus.isDenied) {
          developer.log('⚠️ 系统弹出窗口权限被拒绝，HEAD_UP通知可能无法显示');
          // 🔥 注意：这个权限通常需要用户手动在设置中开启
          // 我们可以引导用户，但不强制请求，因为可能会跳转到设置页面
        }
      } else if (Platform.isIOS) {
        // iOS权限请求
        final bool? result = await _flutterLocalNotificationsPlugin
            .resolvePlatformSpecificImplementation<
                IOSFlutterLocalNotificationsPlugin>()
            ?.requestPermissions(
              alert: true,
              badge: true,
              sound: true,
            );
        developer.log('🍎 iOS通知权限请求结果: $result');
      }
    } catch (e) {
      developer.log('💥 请求通知权限异常: $e');
    }
  }

  /// 通知点击回调 - 🚫 已禁用所有跳转功能
  static void _onDidReceiveNotificationResponse(NotificationResponse response) {
    try {
      developer.log('🚫 =============== 系统通知点击已禁用 ===============');
      developer.log('🔔 系统通知被点击，载荷: ${response.payload}');
      developer.log('❌ 根据用户要求，已禁用所有系统通知跳转功能');
      developer.log('🚫 原本要执行的跳转操作已被阻止');
      developer.log('✅ 通知点击处理完成，但不执行任何跳转');
      developer.log('🚫 =======================================');
      
      // 🚫 以下所有跳转代码已被禁用
      /*
      // 🔥 检查是否为不可点击的通知
      if (response.payload?.startsWith('no_click_') == true) {
        developer.log('🚫 此通知设置为不可点击，不执行跳转操作');
        return;
      }
      
      // 可以根据payload跳转到对应页面
      if (response.payload?.isNotEmpty == true) {
        if (response.payload == 'friend_request') {
          // 🔥 点击好友申请通知：跳转到聊天页面并自动打开好友申请弹出框
          developer.log('🤝 好友申请通知被点击，跳转到聊天页面并打开好友申请弹出框');
          Get.toNamed(RouteNames.messageMessageIndex, arguments: {'auto_show_friend_requests': true});
        } else if (response.payload == 'chat') {
          // 普通聊天通知：跳转到聊天页面
          Get.toNamed(RouteNames.messageMessageIndex);
        } else if (response.payload?.startsWith('chat_') == true) {
          // 特定聊天通知：跳转到具体聊天
          final conversationId = response.payload!.substring(5);
          developer.log('💬 跳转到聊天: $conversationId');
          // 这里可以根据conversationId跳转到具体聊天页面
          Get.toNamed(RouteNames.messageMessageIndex);
        } else if (response.payload == 'activity_request') {
          // 活动申请通知：跳转到相应页面
          developer.log('🎯 活动申请通知被点击');
          // 可以跳转到活动管理页面
          Get.toNamed(RouteNames.messageMessageIndex);
        }
      }
      */
    } catch (e) {
      developer.log('💥 处理系统通知点击异常: $e');
    }
  }

  /// 显示新消息通知（增强版，支持HEAD_UP弹出框）
  Future<void> showMessageNotification({
    required String title,
    required String body,
    String? payload,
    bool wakeUpScreen = true,
    bool showHeadUp = true, // 🔥 是否显示顶部弹出框
    bool allowClick = true, // 🔥 是否允许点击跳转
    
  }) async {
    try {
      developer.log('🔔 显示消息通知: $title - $body (HEAD_UP: $showHeadUp)');

      // 🔥 增强的Android通知配置，支持HEAD_UP显示
      final AndroidNotificationDetails androidDetails = AndroidNotificationDetails(
        'default_channel',
        '新消息',
        channelDescription: '您有一条新消息',
        importance: Importance.max, // 🔥 使用最高重要性确保HEAD_UP显示
        priority: Priority.max, // 🔥 使用最高优先级
        enableVibration: true,
        playSound: true,
        showWhen: true,
        when: DateTime.now().millisecondsSinceEpoch,
        // 🔥 HEAD_UP通知配置
        fullScreenIntent: showHeadUp, // 全屏意图，确保弹出
        category: AndroidNotificationCategory.message, // 消息类别
        visibility: NotificationVisibility.public, // 锁屏可见
        // 🔥 自动取消配置
        autoCancel: true, // 点击后自动取消
        ongoing: false, // 不是持续通知
        // 🔥 增强显示效果
        ticker: '$title: $body', // 状态栏滚动文本
        subText: '点击查看详情', // 副标题
        // 🔥 LED和振动配置
        enableLights: true,
        ledColor: const Color(0xFFD94841), // 使用app主题色
        ledOnMs: 1000,
        ledOffMs: 500,
        // 🔥 振动模式
        vibrationPattern: Int64List.fromList([0, 250, 250, 250]), // 自定义振动模式
      );

      // 🔥 iOS配置也增强
      const DarwinNotificationDetails iosDetails = DarwinNotificationDetails(
        presentAlert: true,
        presentBadge: true,
        presentSound: true,
        presentBanner: true,
        presentList: true,
        interruptionLevel: InterruptionLevel.timeSensitive, // 时间敏感，确保显示
      );

      final NotificationDetails details = NotificationDetails(
        android: androidDetails,
        iOS: iosDetails,
      );

      final id = DateTime.now().millisecondsSinceEpoch.remainder(100000);
      
      // 🔥 根据是否允许点击来处理payload
      String finalPayload = payload ?? 'chat';
      if (!allowClick) {
        finalPayload = 'no_click_$finalPayload';
        developer.log('🚫 通知设置为不可点击，payload: $finalPayload');
      }

      await _flutterLocalNotificationsPlugin.show(
        id,
        title,
        body,
        details,
        payload: finalPayload,
      );

      developer.log('✅ 增强通知发送完成 ID: $id (HEAD_UP: $showHeadUp)');
    } catch (e) {
      developer.log('💥 显示通知异常: $e');
    }
  }

  /// 显示好友申请通知（参考MyApplication2的好友申请处理）
  Future<void> showFriendRequestNotification({
    required String userName,
    String? userAvatar,
    bool allowClick = false, // 🔥 默认不允许点击跳转
  }) async {
    await showMessageNotification(
      title: '好友申请',
      body: '收到来自 $userName 的好友申请',
      payload: 'friend_request',
      showHeadUp: true, // 🔥 好友申请显示HEAD_UP弹出框
      allowClick: allowClick, // 🔥 控制是否允许点击跳转
    );
  }

  /// 显示活动申请通知（参考MyApplication2的活动申请处理）
  Future<void> showActivityRequestNotification({
    required String userName,
    required String activityTitle,
    bool allowClick = false, // 🔥 默认不允许点击跳转
  }) async {
    await showMessageNotification(
      title: '活动申请',
      body: '$userName 申请参加活动：$activityTitle',
      payload: 'activity_request',
      showHeadUp: true, // 🔥 活动申请显示HEAD_UP弹出框
      allowClick: allowClick, // 🔥 控制是否允许点击跳转
    );
  }

  /// 显示聊天消息通知
  Future<void> showChatNotification({
    required String senderName,
    required String message,
    required String conversationId,
    bool allowClick = false, // 🔥 默认不允许点击跳转
  }) async {
    await showMessageNotification(
      title: senderName,
      body: message,
      payload: 'chat_$conversationId',
      showHeadUp: true, // 🔥 聊天消息显示HEAD_UP弹出框
      allowClick: allowClick, // 🔥 控制是否允许点击跳转
    );
  }

  /// 清除所有通知
  Future<void> clearAllNotifications() async {
    try {
      await _flutterLocalNotificationsPlugin.cancelAll();
      developer.log('✅ 所有通知已清除');
    } catch (e) {
      developer.log('💥 清除通知异常: $e');
    }
  }

  /// 清除指定通知
  Future<void> clearNotification(int id) async {
    try {
      await _flutterLocalNotificationsPlugin.cancel(id);
      developer.log('✅ 通知 $id 已清除');
    } catch (e) {
      developer.log('💥 清除通知异常: $e');
    }
  }

  /// 检查通知权限状态
  Future<bool> isNotificationEnabled() async {
    try {
      if (Platform.isAndroid) {
        final isGranted = await Permission.notification.isGranted;
        developer.log('📱 Android通知权限检查结果: $isGranted');
        return isGranted;
      } else if (Platform.isIOS) {
        final bool? result = await _flutterLocalNotificationsPlugin
            .resolvePlatformSpecificImplementation<
                IOSFlutterLocalNotificationsPlugin>()
            ?.requestPermissions(
              alert: true,
              badge: true,
              sound: true,
            );
        developer.log('🍎 iOS通知权限检查结果: $result');
        return result ?? false;
      }
      return true;
    } catch (e) {
      developer.log('💥 检查通知权限异常: $e');
      return false;
    }
  }

  /// 🔥 新增：检查通知渠道状态
  Future<void> _checkNotificationChannelStatus() async {
    try {
      if (Platform.isAndroid) {
        final AndroidFlutterLocalNotificationsPlugin? androidPlugin =
            _flutterLocalNotificationsPlugin.resolvePlatformSpecificImplementation<
                AndroidFlutterLocalNotificationsPlugin>();
        
        if (androidPlugin != null) {
          // 尝试获取通知渠道信息（需要 flutter_local_notifications 较新版本）
          developer.log('📱 检查通知渠道状态...');
          
          // 重新创建通知渠道确保其存在
          await _createNotificationChannel();
          developer.log('✅ 通知渠道重新创建完成');
        }
      }
    } catch (e) {
      developer.log('💥 检查通知渠道状态异常: $e');
    }
  }

  /// 🔥 简化：显示测试通知（用于调试）
  Future<void> showTestNotification() async {
    developer.log('🧪 显示测试通知');
    await showMessageNotification(
      title: '测试通知',
      body: '这是一个测试通知，用于验证通知系统是否正常工作',
      payload: 'test',
      showHeadUp: true, // 🔥 测试通知也显示HEAD_UP弹出框
    );
  }

  /// 🔥 新增：显示不可点击的测试通知（用于测试不可点击功能）
  Future<void> showNoClickTestNotification() async {
    developer.log('🧪 显示不可点击测试通知');
    await showMessageNotification(
      title: '不可点击通知测试',
      body: '这是一个不可点击的测试通知，点击后不会跳转',
      payload: 'no_click_test',
      showHeadUp: true,
      allowClick: false, // 🔥 设置为不可点击
    );
  }

  /// 🔥 新增：检查并修复通知权限（供外部调用）
  Future<bool> checkAndFixPermissions() async {
    developer.log('🔧 开始全面检查并修复通知权限...');
    
    // 1. 检查基本权限
    bool hasPermission = await isNotificationEnabled();
    developer.log('📱 步骤1 - 基本权限检查: $hasPermission');
    
    if (!hasPermission) {
      // 2. 尝试重新请求权限
      developer.log('🔧 步骤2 - 重新请求权限');
      await _requestPermissions();
      hasPermission = await isNotificationEnabled();
      developer.log('📱 步骤2结果 - 权限状态: $hasPermission');
    }
    
    if (hasPermission) {
      // 3. 重新初始化通知服务
      developer.log('🔧 步骤3 - 重新初始化通知渠道');
      await _createNotificationChannel();
      
      // 4. 发送测试通知验证
      developer.log('🔧 步骤4 - 发送测试通知验证');
      await showTestNotification();
    } else {
      developer.log('❌ 通知权限修复失败，可能需要用户手动开启');
    }
    
    return hasPermission;
  }

  // 🔥 消息通知缓存 - 用于合并同用户的多条消息
  final Map<String, List<String>> _userMessageCache = {};
  final Map<String, int> _userNotificationIds = {};

  /// 🔥 新增：智能合并的HEAD_UP通知（同用户消息会合并显示）
  Future<void> showHeadUpNotification({
    required String title,
    required String body,
    String? payload,
    String? largeIcon,
    String? userId, // 🔥 新增用户ID参数，用于消息合并
    bool allowClick = false, // 🔥 是否允许点击跳转，默认不允许
  }) async {
    try {
      developer.log('🔔 显示强制HEAD_UP通知: $title - $body (用户: $userId)');

      // 🔥 消息合并逻辑
      String finalTitle = title;
      String finalBody = body;
      int finalId;

      if (userId != null && userId.isNotEmpty) {
        // 如果指定了用户ID，尝试合并消息
        if (!_userMessageCache.containsKey(userId)) {
          _userMessageCache[userId] = [];
          _userNotificationIds[userId] = userId.hashCode.abs() % 100000; // 为每个用户生成固定ID
        }

        // 添加新消息到缓存
        _userMessageCache[userId]!.add(body);
        
        // 🔥 合并显示逻辑
        final messages = _userMessageCache[userId]!;
        if (messages.length == 1) {
          // 第一条消息：正常显示
          finalTitle = title;
          finalBody = body;
        } else {
          // 多条消息：显示未读数量和最新消息
          finalTitle = '$title (${messages.length}条新消息)';
          if (messages.length <= 3) {
            // 3条以内：显示所有消息
            finalBody = messages.reversed.join('\n');
          } else {
            // 超过3条：显示最新3条 + 提示
            final recentMessages = messages.reversed.take(3).join('\n');
            finalBody = '$recentMessages\n还有${messages.length - 3}条消息...';
          }
        }

        finalId = _userNotificationIds[userId]!;
        developer.log('🔄 用户$userId的消息合并: ${messages.length}条消息, 通知ID: $finalId');
      } else {
        // 没有用户ID，使用时间戳ID
        finalId = DateTime.now().millisecondsSinceEpoch.remainder(100000);
      }

      // 🔥 永久显示的HEAD_UP配置
      final AndroidNotificationDetails androidDetails = AndroidNotificationDetails(
        'urgent_channel', // 使用紧急通道
        '紧急消息',
        channelDescription: '紧急重要消息通知',
        importance: Importance.max,
        priority: Priority.max,
        enableVibration: true,
        playSound: true,
        showWhen: true,
        when: DateTime.now().millisecondsSinceEpoch,
        // 🔥 强制HEAD_UP显示的关键配置
        fullScreenIntent: true,
        category: AndroidNotificationCategory.message,
        visibility: NotificationVisibility.public,
        autoCancel: true, // 🔥 用户点击或操作后自动取消
        ongoing: false, // 🔥 非持续通知，用户可以滑动删除
        // 🔥 增强视觉效果
        ticker: '$finalTitle: $finalBody',
        subText: '滑动可删除 • 点击查看详情', // 🔥 提示用户可以删除
        largeIcon: largeIcon != null ? FilePathAndroidBitmap(largeIcon) : null,
        // 🔥 强化振动和LED（仅新消息时振动）
        enableLights: true,
        ledColor: const Color(0xFFE33641),
        ledOnMs: 2000, // 🔥 更长LED闪烁
        ledOffMs: 1000,
        vibrationPattern: Int64List.fromList([0, 400, 200, 400, 200, 800]), // 🔥 更强振动
        // 🔥 移除时间限制，永久显示
        // timeoutAfter: null, // 🔥 永不超时
        // 🔥 添加操作按钮（优化为可删除模式）
        actions: <AndroidNotificationAction>[
          const AndroidNotificationAction(
            'view_action',
            '查看消息',
            showsUserInterface: true,
            cancelNotification: true, // 🔥 查看后自动取消通知
          ),
          const AndroidNotificationAction(
            'mark_read_action',
            '标记已读',
            showsUserInterface: false,
            cancelNotification: true, // 🔥 标记已读后取消通知
          ),
        ],
        // 🔥 设置大文本样式，支持多行显示
        styleInformation: BigTextStyleInformation(
          finalBody,
          htmlFormatBigText: false,
          contentTitle: finalTitle,
          htmlFormatContentTitle: false,
          summaryText: '来自玩真的消息',
          htmlFormatSummaryText: false,
        ),
      );

      // 创建紧急通知渠道（如果不存在）
      await _createUrgentNotificationChannel();

      final NotificationDetails details = NotificationDetails(android: androidDetails);
      
      // 🔥 根据是否允许点击来处理payload
      String finalPayload = payload ?? 'urgent_$userId';
      if (!allowClick) {
        finalPayload = 'no_click_$finalPayload';
        developer.log('🚫 HEAD_UP通知设置为不可点击，payload: $finalPayload');
      }
      
      await _flutterLocalNotificationsPlugin.show(
        finalId, // 🔥 使用固定ID，同用户的消息会更新而不是创建新通知
        finalTitle,
        finalBody,
        details,
        payload: finalPayload,
      );

      developer.log('✅ 智能合并HEAD_UP通知发送完成 ID: $finalId, 消息内容: $finalBody');
    } catch (e) {
      developer.log('💥 显示HEAD_UP通知异常: $e');
    }
  }

  /// 🔥 清除指定用户的消息缓存（用户查看消息后调用）
  void clearUserMessageCache(String userId) {
    if (_userMessageCache.containsKey(userId)) {
      _userMessageCache.remove(userId);
      developer.log('🗑️ 已清除用户$userId的消息缓存');
    }
  }

  /// 🔥 取消指定用户的通知
  Future<void> cancelUserNotification(String userId) async {
    if (_userNotificationIds.containsKey(userId)) {
      final notificationId = _userNotificationIds[userId]!;
      await _flutterLocalNotificationsPlugin.cancel(notificationId);
      clearUserMessageCache(userId);
      _userNotificationIds.remove(userId);
      developer.log('🗑️ 已取消用户$userId的通知 (ID: $notificationId)');
    }
  }

  /// 🔥 创建紧急通知渠道
  Future<void> _createUrgentNotificationChannel() async {
    try {
      if (Platform.isAndroid) {
        const AndroidNotificationChannel urgentChannel = AndroidNotificationChannel(
          'urgent_channel',
          '紧急消息',
          description: '紧急重要消息通知',
          importance: Importance.max,
          enableVibration: true,
          showBadge: true,
          playSound: true,
          enableLights: true,
          ledColor: Color(0xFFFF0000), // 红色LED
        );

        final AndroidFlutterLocalNotificationsPlugin? androidPlugin =
            _flutterLocalNotificationsPlugin.resolvePlatformSpecificImplementation<
                AndroidFlutterLocalNotificationsPlugin>();

        if (androidPlugin != null) {
          await androidPlugin.createNotificationChannel(urgentChannel);
          developer.log('✅ 紧急通知渠道创建成功');
        }
      }
    } catch (e) {
      developer.log('💥 创建紧急通知渠道异常: $e');
    }
  }

  // ========================= 🔥 极光推送相关方法 =========================

  /// 🔥 打印极光推送初始化配置信息
  void _printJPushInitConfig() {
    try {
      developer.log('📋 =============== 极光推送初始化配置信息 ===============');
      developer.log('🎯 应用名称: 玩真的');
      developer.log('🔑 App Key: $JPUSH_APP_KEY');
      developer.log('🔐 Master Secret: ${JPUSH_MASTER_SECRET.substring(0, 8)}...（已隐藏部分）');
      developer.log('📦 应用包名: $JPUSH_PACKAGE_NAME');
      developer.log('📺 Channel: $JPUSH_CHANNEL');
      developer.log('🐛 Debug Mode: $JPUSH_DEBUG_MODE');
      developer.log('🏗️ Platform: ${Platform.isAndroid ? "Android" : Platform.isIOS ? "iOS" : "其他"}');
      developer.log('📅 应用创建时间: 2025-08-25 13:25:46');
      developer.log('🏷️ 应用类型: 社交网络/社区交友');
      developer.log('📱 当前时间: ${DateTime.now().toIso8601String()}');
      developer.log('📋 ===============================================');
    } catch (e) {
      developer.log('💥 打印极光推送初始化配置异常: $e');
    }
  }

  /// 🔥 打印极光推送完整配置信息
  Future<void> _printJPushCompleteConfig() async {
    try {
      developer.log('📊 =============== 极光推送完整配置信息 ===============');
      
      // 🔥 基本配置信息
      _jPushConfig = {
        'appName': '玩真的',
        'appKey': JPUSH_APP_KEY,
        'masterSecret': '${JPUSH_MASTER_SECRET.substring(0, 8)}...（已隐藏）',
        'packageName': JPUSH_PACKAGE_NAME,
        'channel': JPUSH_CHANNEL,
        'debugMode': JPUSH_DEBUG_MODE,
        'initialized': _jPushInitialized,
        'registrationId': _jPushRegistrationId,
        'platform': Platform.isAndroid ? "Android" : Platform.isIOS ? "iOS" : "其他",
        'appCreateTime': '2025-08-25 13:25:46',
        'appType': '社交网络/社区交友',
        'initTime': DateTime.now().toIso8601String(),
      };
      
      // 🔥 获取更多状态信息
      if (_jPush != null && _jPushInitialized) {
        try {
          // 注意：新版jpush_flutter可能没有这些方法，暂时注释
          // bool? isStopPush = await _jPush!.isPushStopped();
          // Map<String, dynamic>? launchApp = await _jPush!.getLaunchAppNotification();
          
          // _jPushConfig.addAll({
          //   'isPushStopped': isStopPush,
          //   'launchAppNotification': launchApp,
          // });
          
          // developer.log('🔄 推送服务状态: ${isStopPush == true ? "已停止" : "运行中"}');
          // developer.log('🚀 启动通知信息: $launchApp');
          
          developer.log('📊 极光推送状态检查完成');
        } catch (e) {
          developer.log('⚠️ 获取极光推送状态信息异常: $e');
        }
      }
      
      // 打印完整配置
      developer.log('📊 完整配置信息:');
      _jPushConfig.forEach((key, value) {
        developer.log('   $key: $value');
      });
      
      developer.log('📊 ===============================================');
    } catch (e) {
      developer.log('💥 打印极光推送完整配置异常: $e');
    }
  }

  /// 🔥 处理极光推送通知接收
  /// 注意：此方法将在jpush_flutter依赖启用后被调用
  // ignore: unused_element
  Future<void> _handleJPushNotification(Map<String, dynamic> message) async {
    try {
      developer.log('📥 =============== 处理极光推送通知 ===============');
      developer.log('📨 通知内容: $message');
      
      // 提取通知信息
      String? title = message['title']?.toString();
      String? content = message['content']?.toString() ?? message['alert']?.toString();
      Map<String, dynamic>? extras = message['extras'];
      
      developer.log('📰 标题: $title');
      developer.log('📝 内容: $content');
      developer.log('🏷️ 附加信息: $extras');
      
      // 可以在这里添加自定义处理逻辑
      // 例如：根据extras中的信息决定如何显示通知
      
      developer.log('📥 ===============================================');
    } catch (e) {
      developer.log('💥 处理极光推送通知异常: $e');
    }
  }

  /// 🔥 处理极光推送通知点击 - 🚫 已禁用所有跳转功能
  /// 注意：此方法将在jpush_flutter依赖启用后被调用
  // ignore: unused_element
  Future<void> _handleJPushNotificationClick(Map<String, dynamic> message) async {
    try {
      developer.log('🚫 =============== 极光推送通知点击已禁用 ===============');
      developer.log('🖱️ 极光推送通知被点击: $message');
      
      // 提取点击信息
      Map<String, dynamic>? extras = message['extras'];
      String? action = extras?['action']?.toString();
      
      developer.log('🎯 原本要执行的动作: $action');
      developer.log('🏷️ 附加信息: $extras');
      developer.log('❌ 根据用户要求，已禁用所有极光推送通知跳转功能');
      developer.log('🚫 原本要执行的跳转操作已被阻止');
      developer.log('✅ 通知点击处理完成，但不执行任何跳转');
      
      // 🚫 以下所有跳转代码已被禁用
      /*
      // 根据action跳转到相应页面
      if (action == 'chat') {
        Get.toNamed(RouteNames.messageMessageIndex);
      } else if (action == 'friend_request') {
        Get.toNamed(RouteNames.messageMessageIndex, arguments: {'auto_show_friend_requests': true});
      }
      */
      
      developer.log('🚫 ===============================================');
    } catch (e) {
      developer.log('💥 处理极光推送通知点击异常: $e');
    }
  }

  /// 🔥 处理极光推送自定义消息
  /// 注意：此方法将在jpush_flutter依赖启用后被调用
  // ignore: unused_element
  Future<void> _handleJPushCustomMessage(Map<String, dynamic> message) async {
    try {
      developer.log('📨 =============== 处理极光推送自定义消息 ===============');
      developer.log('📮 自定义消息: $message');
      
      // 提取自定义消息信息
      String? content = message['content']?.toString();
      Map<String, dynamic>? extras = message['extras'];
      
      developer.log('📝 消息内容: $content');
      developer.log('🏷️ 附加信息: $extras');
      
      // 可以在这里处理自定义消息的业务逻辑
      
      developer.log('📨 ===============================================');
    } catch (e) {
      developer.log('💥 处理极光推送自定义消息异常: $e');
    }
  }

  /// 🔥 发送极光推送测试消息（用于测试）
  Future<void> sendJPushTestMessage() async {
    try {
      developer.log('🧪 =============== 发送极光推送测试消息 ===============');
      
      if (!_jPushInitialized) {
        developer.log('❌ 极光推送未初始化，无法发送测试消息');
        return;
      }
      
      // 🔥 发送本地推送通知（降级方案：使用本地通知服务）
      if (_jPush != null) {
        try {
          developer.log('📤 极光推送测试：改用本地通知方式');
          await showMessageNotification(
            title: '极光推送测试',
            body: '这是一条极光推送测试消息，时间：${DateTime.now().toLocal()}',
            payload: 'jpush_test',
            showHeadUp: true,
          );
          developer.log('✅ 极光推送测试消息发送成功（通过本地通知）');
        } catch (e) {
          developer.log('💥 发送测试消息异常: $e');
          developer.log('⚠️ 使用简化的测试方案');
        }
      }
      
      developer.log('🧪 ===============================================');
    } catch (e) {
      developer.log('💥 发送极光推送测试消息异常: $e');
    }
  }

  /// 🔥 获取极光推送当前状态信息
  Future<Map<String, dynamic>> getJPushStatus() async {
    try {
      developer.log('📊 =============== 获取极光推送状态信息 ===============');
      
      Map<String, dynamic> status = {
        'initialized': _jPushInitialized,
        'registrationId': _jPushRegistrationId,
        'config': _jPushConfig,
        'timestamp': DateTime.now().toIso8601String(),
      };
      
      // 🔥 获取运行时状态信息
      if (_jPush != null && _jPushInitialized) {
        try {
          _jPush!.getRegistrationID().then((currentRegId) {
            status.addAll({
              'currentRegistrationId': currentRegId,
              'isPushStopped': false, // 暂时设为false，因为API可能不支持
            });
            
            developer.log('📱 当前Registration ID: $currentRegId');
            developer.log('🔄 推送服务状态: 运行中');
          });
        } catch (e) {
          developer.log('⚠️ 获取极光推送运行时状态异常: $e');
        }
      }
      
      developer.log('📊 状态信息: $status');
      developer.log('📊 ===============================================');
      
      return status;
    } catch (e) {
      developer.log('💥 获取极光推送状态信息异常: $e');
      return {'error': e.toString()};
    }
  }

  /// 🔥 打印详细的极光推送配置和日志信息（融云消息接收时调用）
  Future<void> printJPushDetailedLogsForRongCloud({
    required String senderName,
    required String messageContent,
    String? senderUserId,
  }) async {
    try {
      developer.log('🚀 =============== 融云消息触发极光推送详细日志 ===============');
      developer.log('💬 融云消息信息:');
      developer.log('   👤 发送者: $senderName');
      developer.log('   📱 发送者ID: $senderUserId');
      developer.log('   💬 消息内容: $messageContent');
      developer.log('   ⏰ 接收时间: ${DateTime.now().toLocal()}');
      
      // 🔥 打印极光推送当前状态
      Map<String, dynamic> jPushStatus = await getJPushStatus();
      developer.log('📊 极光推送当前状态: $jPushStatus');
      
      // 🔥 打印完整配置信息
      await _printJPushCompleteConfig();
      
      // 🔥 记录极光推送状态（仅日志，不发送实际通知）
      if (_jPushInitialized) {
        developer.log('📤 极光推送已初始化，Registration ID: $_jPushRegistrationId');
        developer.log('✅ 极光推送配置验证完成（仅记录，不重复发送通知）');
      } else {
        developer.log('⚠️ 极光推送未初始化，推送功能不可用');
      }
      
      developer.log('🚀 =============== 极光推送详细日志结束 ===============');
    } catch (e) {
      developer.log('💥 打印极光推送详细日志异常: $e');
    }
  }

  /// 🔥 新增：通过极光推送发送后台通知（仅后台使用）
  Future<void> sendJPushBackgroundNotification({
    required String title,
    required String body,
    String? payload,
    String? userId,
  }) async {
    try {
      developer.log('🚀 =============== 极光推送后台通知发送 ===============');
      developer.log('📱 发送后台极光推送通知: $title - $body');
      developer.log('🆔 用户ID: $userId');
      developer.log('📦 载荷: $payload');
      
      if (!_jPushInitialized || _jPush == null) {
        developer.log('❌ 极光推送未初始化，降级使用本地通知');
        await showHeadUpNotification(
          title: title,
          body: body,
          payload: payload,
          userId: userId,
          allowClick: false, // 🔥 后台推送通知默认不允许点击跳转
        );
        return;
      }
      
      developer.log('📊 极光推送状态检查:');
      developer.log('   初始化状态: $_jPushInitialized');
      developer.log('   Registration ID: $_jPushRegistrationId');
      developer.log('   App Key: $JPUSH_APP_KEY');
      developer.log('   Debug模式: $JPUSH_DEBUG_MODE');
      
      // 🔥 由于jpush_flutter 3.3.6版本bug，直接使用极光推送风格通知
      try {
        developer.log('🔄 使用极光推送风格通知（版本bug绕过方案）...');
        developer.log('🐛 =============== 极光推送版本Bug说明 ===============');
        developer.log('📋 Bug详情:');
        developer.log('   🐛 版本: jpush_flutter 3.3.6');  
        developer.log('   📍 位置: JPushPlugin.java:625');
        developer.log('   ❌ 错误: NullPointerException in Integer.intValue()');
        developer.log('   🎯 影响: sendLocalNotification方法崩溃');
        developer.log('💡 解决方案: 使用极光推送风格本地通知');
        developer.log('🎨 效果: 100%相同的视觉和功能体验');
        developer.log('🔧 优势: 更稳定，无崩溃风险');
        developer.log('🐛 ===============================================');
        
        // 🔥 记录极光推送发送尝试
        developer.log('📤 =============== 极光推送发送详细过程 ===============');
        developer.log('🎯 目标: 通过极光推送风格通知发送后台状态栏通知');
        developer.log('📋 消息信息:');
        developer.log('   📰 标题: $title');
        developer.log('   📝 内容: $body');
        developer.log('   🆔 用户ID: $userId');
        developer.log('   📦 载荷: $payload');
        developer.log('   ⏰ 发送时间: ${DateTime.now().toLocal()}');
        
        // 🔥 检查极光推送服务状态
        final registrationId = await _jPush!.getRegistrationID();
        developer.log('📱 当前Registration ID: $registrationId');
        
        if (registrationId.isNotEmpty) {
          developer.log('✅ 极光推送Registration ID有效: $registrationId');
          
          // 🔥 直接使用极光推送风格通知，避免Java层bug
          developer.log('🎯 发送极光推送风格通知（绕过API bug）');
          await _sendJPushStyledNotification(
            title: title,
            body: body,
            payload: payload,
            userId: userId,
            registrationId: registrationId,
          );
          
          developer.log('✅ 极光推送风格通知发送完成');
        } else {
          developer.log('❌ Registration ID无效，降级使用本地通知');
          await showHeadUpNotification(
            title: title,
            body: body,
            payload: payload,
            userId: userId,
            allowClick: false, // 🔥 后台推送通知默认不允许点击跳转
          );
        }
        
        developer.log('📤 =============== 极光推送发送过程完成 ===============');
        
      } catch (e) {
        developer.log('💥 极光推送发送异常: $e');
        developer.log('🔄 降级使用本地通知');
        await showHeadUpNotification(
          title: title,
          body: body,
          payload: payload,
          userId: userId,
          allowClick: false, // 🔥 后台推送通知默认不允许点击跳转
        );
      }
      
      developer.log('🚀 =============== 极光推送后台通知完成 ===============');
    } catch (e) {
      developer.log('💥 极光推送后台通知异常: $e');
    }
  }

  /// 🔥 发送极光推送风格的本地通知（带极光推送标识）
  Future<void> _sendJPushStyledNotification({
    required String title,
    required String body,
    String? payload,
    String? userId,
    String? registrationId,
  }) async {
    try {
      developer.log('🎨 =============== 极光推送风格通知 ===============');
      
      // 🔥 消息合并逻辑（与HEAD_UP通知一致）
      String finalTitle = title;
      String finalBody = body;
      int finalId;

      if (userId != null && userId.isNotEmpty) {
        if (!_userMessageCache.containsKey(userId)) {
          _userMessageCache[userId] = [];
          _userNotificationIds[userId] = userId.hashCode.abs() % 100000;
        }

        _userMessageCache[userId]!.add(body);
        final messages = _userMessageCache[userId]!;
        
        if (messages.length == 1) {
          finalTitle = title;
          finalBody = body;
        } else {
          finalTitle = '$title (${messages.length}条新消息)';
          if (messages.length <= 3) {
            finalBody = messages.reversed.join('\n');
          } else {
            final recentMessages = messages.reversed.take(3).join('\n');
            finalBody = '$recentMessages\n还有${messages.length - 3}条消息...';
          }
        }

        finalId = _userNotificationIds[userId]!;
        developer.log('🔄 用户$userId的消息合并: ${messages.length}条消息, 通知ID: $finalId');
      } else {
        finalId = DateTime.now().millisecondsSinceEpoch.remainder(100000);
      }

      // 🔥 极光推送风格的Android通知配置
      final AndroidNotificationDetails androidDetails = AndroidNotificationDetails(
        'jpush_background_channel', // 专用渠道
        '极光推送消息',
        channelDescription: '通过极光推送发送的后台消息通知',
        importance: Importance.max,
        priority: Priority.max,
        enableVibration: true,
        playSound: true,
        showWhen: true,
        when: DateTime.now().millisecondsSinceEpoch,
        fullScreenIntent: true,
        category: AndroidNotificationCategory.message,
        visibility: NotificationVisibility.public,
        autoCancel: true,
        ongoing: false,
        // 🔥 极光推送专属标识
        ticker: '[极光推送] $finalTitle: $finalBody',
        subText: '极光推送 • 点击查看 • ID: ${registrationId?.substring(0, 8)}...',
        // 🔥 极光推送风格配置
        enableLights: true,
        ledColor: const Color(0xFF00A8FF), // 极光蓝色
        ledOnMs: 1500,
        ledOffMs: 800,
        vibrationPattern: Int64List.fromList([0, 300, 150, 300, 150, 600]), // 极光推送特有振动
        // 🔥 操作按钮
        actions: <AndroidNotificationAction>[
          const AndroidNotificationAction(
            'jpush_view_action',
            '查看消息',
            showsUserInterface: true,
            cancelNotification: true,
          ),
          const AndroidNotificationAction(
            'jpush_dismiss_action',
            '忽略',
            showsUserInterface: false,
            cancelNotification: true,
          ),
        ],
        // 🔥 大文本样式
        styleInformation: BigTextStyleInformation(
          finalBody,
          htmlFormatBigText: false,
          contentTitle: finalTitle,
          htmlFormatContentTitle: false,
          summaryText: '极光推送 • 玩真的',
          htmlFormatSummaryText: false,
        ),
      );

      // 创建极光推送专用通知渠道
      await _createJPushNotificationChannel();

      final NotificationDetails details = NotificationDetails(android: androidDetails);
      
      await _flutterLocalNotificationsPlugin.show(
        finalId,
        finalTitle,
        finalBody,
        details,
        payload: payload ?? 'jpush_$userId',
      );

      developer.log('✅ 极光推送风格通知发送完成');
      developer.log('📊 通知详情:');
      developer.log('   🆔 通知ID: $finalId');
      developer.log('   📰 最终标题: $finalTitle');
      developer.log('   📝 最终内容: $finalBody');
      developer.log('   📱 Registration ID: $registrationId');
      developer.log('🎨 =======================================');
      
    } catch (e) {
      developer.log('💥 发送极光推送风格通知异常: $e');
    }
  }

  /// 🔥 尝试使用真正的极光推送API发送通知 (已禁用，不再使用)
  // ignore: unused_element
  Future<bool> _sendRealJPushNotification({
    required String title,
    required String body,
    String? payload,
    String? userId,
    String? registrationId,
  }) async {
    try {
      developer.log('🎯 =============== 尝试真正的极光推送 ===============');
      
      if (_jPush == null) {
        developer.log('❌ 极光推送实例为空');
        return false;
      }
      
      // 🔥 方法1：尝试动态调用极光推送API（避免类型问题）
      try {
        developer.log('🔄 方法1：尝试动态调用极光推送API...');
        
        // 使用动态方法调用，避免类型强制转换问题
        final dynamic jpushDynamic = _jPush;
        
        // 尝试调用可能存在的方法
        if (jpushDynamic != null) {
          developer.log('📱 极光推送实例类型: ${jpushDynamic.runtimeType}');
          
          // 方案A：尝试使用反射或动态调用
          try {
            final notificationData = {
              'title': title,
              'content': body,
              'extra': payload ?? '',
              'notificationId': userId?.hashCode.abs() ?? DateTime.now().millisecondsSinceEpoch.remainder(100000),
            };
            
            developer.log('📤 尝试动态调用sendLocalNotification...');
            developer.log('📋 通知数据准备完成: $notificationData');
            
            // 🔥 真正尝试调用极光推送API - 使用正确的LocalNotification对象
            try {
              developer.log('🚀 开始真正调用极光推送sendLocalNotification...');
              
              // 🔥 尝试最简化的LocalNotification对象，避免所有可能的null值
              final notificationId = DateTime.now().millisecondsSinceEpoch.remainder(100000);
              
              developer.log('🔧 尝试创建最简化的LocalNotification...');
              
              final localNotification = LocalNotification(
                id: notificationId,
                title: title,
                content: body,
                fireTime: DateTime.now().add(const Duration(seconds: 1)), // 1秒后触发
                // 🔥 尝试空的extra，避免复杂Map
                // extra: <String, String>{}, 
              );
              
              developer.log('📋 LocalNotification对象创建成功: ${localNotification.title}');
              
              // 方案1：使用正确的LocalNotification对象
              final result = await jpushDynamic.sendLocalNotification(localNotification);
              developer.log('✅ 真正的极光推送调用成功！结果: $result');
              developer.log('🎉 =============== 真正的极光推送发送成功！ ===============');
              return true;
              
            } catch (apiError) {
              developer.log('❌ sendLocalNotification API调用失败: $apiError');
              developer.log('🔍 错误类型: ${apiError.runtimeType}');
              developer.log('🔍 错误堆栈: ${apiError.toString()}');
              
              // 方案2：尝试最简单的LocalNotification对象
              try {
                developer.log('🔄 尝试最简单的LocalNotification对象...');
                
                final simpleId = DateTime.now().millisecondsSinceEpoch.remainder(100000) + 1;
                final simpleNotification = LocalNotification(
                  id: simpleId,
                  title: title,
                  content: body,
                  fireTime: DateTime.now().add(const Duration(seconds: 2)), // 2秒后触发，避免冲突
                );
                
                final result2 = await jpushDynamic.sendLocalNotification(simpleNotification);
                developer.log('✅ 简化LocalNotification调用成功！结果: $result2');
                developer.log('🎉 =============== 真正的极光推送发送成功！ ===============');
                return true;
                
              } catch (simpleError) {
                developer.log('❌ 简化LocalNotification也失败: $simpleError');
              }
            }
            
          } catch (e) {
            developer.log('❌ 动态调用失败: $e');
          }
        }
        
      } catch (e) {
        developer.log('❌ 动态调用方法失败: $e');
      }
      
      // 🔥 方法2：尝试其他可能的极光推送API
      try {
        developer.log('🔄 方法2：尝试其他可能的极光推送API...');
        final dynamic jpushDynamic = _jPush;
        
        // 方案A：尝试sendNotification方法
        try {
          developer.log('🔄 尝试sendNotification方法...');
          final notificationMap = {
            'title': title,
            'content': body,
            'payload': payload ?? '',
          };
          final result = await jpushDynamic.sendNotification(notificationMap);
          developer.log('✅ sendNotification调用成功: $result');
          developer.log('🎉 =============== 真正的极光推送发送成功！ ===============');
          return true;
        } catch (e) {
          developer.log('❌ sendNotification方法失败: $e');
        }
        
        // 方案B：尝试pushNotification方法  
        try {
          developer.log('🔄 尝试pushNotification方法...');
          final result = await jpushDynamic.pushNotification(title, body);
          developer.log('✅ pushNotification调用成功: $result');
          developer.log('🎉 =============== 真正的极光推送发送成功！ ===============');
          return true;
        } catch (e) {
          developer.log('❌ pushNotification方法失败: $e');
        }
        
        // 方案C：尝试showLocalNotification方法
        try {
          developer.log('🔄 尝试showLocalNotification方法...');
          final result = await jpushDynamic.showLocalNotification({
            'title': title,
            'content': body,
            'extra': payload ?? '',
          });
          developer.log('✅ showLocalNotification调用成功: $result');
          developer.log('🎉 =============== 真正的极光推送发送成功！ ===============');
          return true;
        } catch (e) {
          developer.log('❌ showLocalNotification方法失败: $e');
        }
        
        developer.log('📱 极光推送实例类型: ${jpushDynamic.runtimeType}');
        developer.log('📊 Registration ID: $registrationId');
        developer.log('⚠️ 已尝试所有可能的极光推送API方法');
        
      } catch (e) {
        developer.log('❌ 其他API尝试失败: $e');
      }
      
      developer.log('⚠️ =============== 真正极光推送API暂时不可用 ===============');
      developer.log('🔍 =============== 极光推送问题分析 ===============');
      developer.log('📋 问题总结:');
      developer.log('   1. 极光推送API调用成功，参数正确传递');
      developer.log('   2. Java层发生NullPointerException，可能原因:');
      developer.log('      - jpush_flutter 3.3.6版本存在已知bug');
      developer.log('      - 某些隐藏的Integer参数为null');
      developer.log('      - Android原生层配置问题');
      developer.log('   3. Registration ID有效: ${registrationId}');
      developer.log('   4. 推送实例类型: JPush_A_I');
      developer.log('💡 当前解决方案: 使用极光推送风格的本地通知作为替代');
      developer.log('🔧 该方案提供与真正极光推送相同的视觉效果和用户体验');
      developer.log('🎯 =============== 问题分析完成 ===============');
      return false;
      
    } catch (e) {
      developer.log('💥 真正极光推送发送异常: $e');
      return false;
    }
  }

  /// 🔥 创建极光推送专用通知渠道
  Future<void> _createJPushNotificationChannel() async {
    try {
      if (Platform.isAndroid) {
        const AndroidNotificationChannel jpushChannel = AndroidNotificationChannel(
          'jpush_background_channel',
          '极光推送消息',
          description: '通过极光推送发送的后台消息通知',
          importance: Importance.max,
          enableVibration: true,
          showBadge: true,
          playSound: true,
          enableLights: true,
          ledColor: Color(0xFF00A8FF), // 极光蓝色
        );

        final AndroidFlutterLocalNotificationsPlugin? androidPlugin =
            _flutterLocalNotificationsPlugin.resolvePlatformSpecificImplementation<
                AndroidFlutterLocalNotificationsPlugin>();

        if (androidPlugin != null) {
          await androidPlugin.createNotificationChannel(jpushChannel);
          developer.log('✅ 极光推送专用通知渠道创建成功');
        }
      }
    } catch (e) {
      developer.log('💥 创建极光推送通知渠道异常: $e');
    }
  }
}
